La composition symbolique du modèle permet de définir:

• Ses entrants et les variables réponse
  
• Sa structure
  
• Sa fonction objective (RMSE, MAE, Softmax, …)

data<- mx.symbol.Variable(name = "data")
final<- mx.symbol.FullyConnected(data=data, num_hidden=1, name = "final")
perte<- mx.symbol.LinearRegressionOutput(data=final, name = "perte_lineaire")

Aucun calcul n'est réalisé à cette étape. Seule la structure du modèle est définie afin de déterminer les dépendances de calculs aux fins d'optimisation de l'exécution et la gestion de la mémoire.

data<- mx.symbol.Variable(name = "data")
fc1<- mx.symbol.FullyConnected(data=data, num_hidden=5, name = "fc_1")
act1<- mx.symbol.Activation(data=fc1, act_type="relu", name = "act_1")
final<- mx.symbol.FullyConnected(data=act1, num_hidden=1, name = "final")
perte<- mx.symbol.LinearRegressionOutput(data=final, name = "perte_lineaire")

Une fois la structure du modèle définie, il reste à mettre en place les composantes qui permettront à l'algorithme de s'exécuter sur les données réelles.

• Itérateur de données: module dont l'exécution renvoie les données entrantes les variables réponse.

• Optimiseur: module qui définit la façon dont les paramètres sont mis à jour à chaque itération.

• Exécuteur: instance qui exécute les calculs. Il peut y en avoir un seul (CPU) ou plusieurs (multi-GPU).

• Initialisation: spécifie la manière dont sont assignés les paramètres avant l'exécution de l'optimisation.
  • Normal
    
  • Uniforme
    
  • Xavier

initializer_uniform = mx.init.uniform(0.01)
initializer_normal = mx.init.normal(0.01)
initializer_Xavier = mx.init.Xavier(rnd_type = "gaussian", factor_type = "avg", magnitude = 2)

La tâche de l'itérateur est de fournir aux exécuteurs les données nécessaires aux calculs pour chacune des itérations sur les mini-batch.

Les itérateurs pré-définis sont:

• mx.io.arrayiter: itérateur prenant un objet array comme entrée
  
• mx.io.CSVIter: lecture d'un CSV
  
• mx.io.ImageRecordIter: lecture d'images en format binaire

Des itérateurs personnalisés peuvent être construits directement en R, leur performance dépend des fonctionnalités sous-jacentes.

À noter que l'utilisation d'itérateurs sur des CSV ou images permet d'éviter la contrainte de charger la totalité des données en mémoire.

MXNet fonctionne par défaut avec des données orientées par colonnes (chaque observation se trouve dans une colonne différente).

train_iter<- mx.io.arrayiter(data = t(train_x), label = train_y, batch.size = 16, shuffle = T)
eval_iter<- mx.io.arrayiter(data = t(eval_x), label = eval_y, batch.size = 16, shuffle = F)

Crédit: Alec Radford

optimizer_sgd<- mx.opt.create(name = "sgd", learning.rate=0.001, momentum=0.9, wd=0.01, clip_gradient = 1)
optimizer_adadelta<- mx.opt.create(name = "adadelta", rho=0.90, epsilon=1e-5, wd=0.01, clip_gradient = 1)

Crédit: mxnet.io

model_reg<- mx.model.FeedForward.create(symbol = perte, 
                                        num.round = 5, 
                                        X = train_iter,
                                        eval.data = eval_iter,
                                        ctx = mx.cpu(),
                                        optimizer = optimizer_adadelta,
                                        eval.metric = mx.metric.rmse, 
                                        initializer = initializer_uniform,
                                        epoch.end.callback = mx.callback.log.train.metric(1),
                                        verbose = T
)

## Start training with 1 devices
## [1] Train-rmse=17.5212768550543
## [1] Validation-rmse=9.6408607784258
## [2] Train-rmse=11.0480198418688
## [2] Validation-rmse=8.09832961830403
## [3] Train-rmse=9.88505125968133
## [3] Validation-rmse=8.14051313711247
## [4] Train-rmse=9.57003935358424
## [4] Validation-rmse=8.38550654312296
## [5] Train-rmse=9.42705707073436
## [5] Validation-rmse=8.53910092862888

Un modèle peut être représenté comme la combinaison de 2 composantes:

• Structure symbolique: graph représentant l'enchaînement des différents opérateurs
  
• Paramètres: les poids associés aux opérateurs

Un modèle performant bien à une tâche peut fournir une bonne base pour des tâches connexes.

Exemple: Chat vs Chien avec Resnet Microsoft 2015

1. Charger le modèles de référence (Resnet)
   
2. Adapter la structure au nouveau problème (changer le nombre de neuronnes de la dernière couche de 1000 à 2)
   
3. Réutiliser les poids du modèle de référence pour tous les opérateurs saufs ceux qui ont été adaptés.
4. Initialiser aléatoirement les paramètres qui ne sont pas transférés du modèle de référence.
5. Run!

Une collection de modèles pré-entraînées est disponible dans le zoo

Crédit: Zang et Wallace et WildML

Les modès récurrents (RNN) forment une famille de modèles ayant mené à des avancées pas moins significatives que ce qu'ont permis les CNN, notamment pour la traduction machine (Google Translate).

Crédit: Andrej Karpathy

Les modèle adversial recoupe une famille de modèles dont le trait commun est de mettre en compétition 2 sous-modèles:

• Générateur: à partir de bruit, génère une réponse (image, texte, vecteur…)
  
• Discriminateur: identifie si la valeur d'entrée provient d'un échantillon réel ou a plutôt été produit par le générateur

Crédit: Rowel Atienza

Le GAN conditionel est une variation permettant de générer un objet ayant des caractéristiques spécifiques. Ça peut être l'étiquette de la classe (ex: un chiffre pour MNIST) ou encore une expression plus élaborée (ex: un chat noir sur une chaise verte).

Crédit: Scott Reed